﻿@{
    Layout = null;
}

<!DOCTYPE html>

<html>
<head>
    <title>Index</title>
    <script type="text/javascript">


        var Calculator = function (decimalDigits, tax) {
            this.decimalDigits = decimalDigits;
            this.tax = tax;


        };

        /*
        Calculator.prototype = {
            add: function (x, y) {
                return x + y;
            },

            subtract: function (x, y) {
                return x - y;
            }
        };
        //alert((new Calculator()).add(1, 3));
        */

        /*
        Calculator.prototype = function () {
            add = function (x, y) {
                return x + y;
            },

            subtract = function (x, y) {
                return x - y;
            }
            return {
                add: add,
                subtract: subtract
            }
        } ();
        alert((new Calculator()).add(1, 3));
        */

        /*
        var a = {
            x: 10,
            calculate: function (z) {
                return this.x + this.y + z
            }
        };

        var b = {
            y: 20,
            __proto__: a
        };

        var c = {
            y: 30,
            __proto__: a
        };

        // 调用继承过来的方法
      var _b =  b.calculate(30); // 60
      var _c =  c.calculate(40); // 80
      */

      // 构造函数
    function Foo(y) {
      // 构造函数将会以特定模式创建对象：被创建的对象都会有"y"属性
      this.y = y;
    }
 
    // "Foo.prototype"存放了新建对象的原型引用
    // 所以我们可以将之用于定义继承和共享属性或方法
    // 所以，和上例一样，我们有了如下代码：
 
    // 继承属性"x"
    Foo.prototype.x = 10;
 
    // 继承方法"calculate"
    Foo.prototype.calculate = function (z) {
      return this.x + this.y + z;
    };
 
    // 使用foo模式创建 "b" and "c"
    var b = new Foo(20);
    var c = new Foo(30);
 
    // 调用继承的方法
   var _b = b.calculate(30); // 60
   var _c = c.calculate(40); // 80

   console.log("b:" + _b, "c:" + _c);
 
    // 让我们看看是否使用了预期的属性

    console.log(

      b.__proto__ === Foo.prototype, // true
      c.__proto__ === Foo.prototype, // true

    // "Foo.prototype"自动创建了一个特殊的属性"constructor"
    // 指向a的构造函数本身
    // 实例"b"和"c"可以通过授权找到它并用以检测自己的构造函数

      b.constructor === Foo, // true
      c.constructor === Foo, // true
      Foo.prototype.constructor === Foo, // true

      b.calculate === b.__proto__.calculate, // true
      b.__proto__.calculate === Foo.prototype.calculate // true

    );



    var foo = 10;

    function bar() { } // // 函数声明
    (function baz() { }); // 函数表达式

    console.log(
      this.foo == foo, // true
      window.bar == bar // true
    );

    //console.log(baz); // 引用错误，baz没有被定义


    var x = 10;

    (function foo() {
        var y = 20;
        (function bar() {
            var z = 30;
            // "x"和"y"是自由变量
            // 会在作用域链的下一个对象中找到（函数”bar”的互动对象之后）
            console.log(x + y + z);
        })();
    })();


   
    </script>
</head>
<body>
    <div>
        JavaScript
    </div>
</body>
</html>
